<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        // function Human(name,age){
        //  this.name = name
        //  this.age = age
        // }
        // var xiaoming=new Huaman('小明',10)
        // console.log(xiaoming)
        //构造函数中return基础数据类型,返回的结果是由this组成的对象
        //构造函数中return引用数据类型,返回这个引用数据类型
 
        //构造函数定义 == 字面量定义
 
        //对象  toString  valueOf
        //字符串String  数字Number 对象Object 数组Array 函数Function 布尔值Boolean ......   prototype
 
 
        let str1 = 'abc'
        let num1 = 100
        let bool = true
        let arr1 = [1, 2, 3]
        let obj = {}
        let demo = function () { }
 
        console.log(str1.constructor) //ƒ String() { [native code] }
        console.log(num1.constructor) //ƒ Number() { [native code] }
        console.log(bool.constructor) //f Boolean() { [native code] }
        console.log(arr1.constructor) //ƒ Array() { [native code] }
        console.log(obj.constructor)  //ƒ Object() { [native code] }
        console.log(demo.constructor) //f Function() { [native code] }
 
        //typeof主要用于判断基础数据类型的类型
        //instanceof主要应用于引用数据类型的判断
        //constructor可以判断所有的数据类型
        function Animal() {
            this.eat = function () {
                console.log('吃')
            }
        }
        function Human(name, age) { //工厂
            this.name = name
            this.age = age
        }
        //原型是一个对象
        Human.prototype = new Animal() //{eat: fun}
        let xiaoming = new Human('小明', 22)  //实例
        let xiaohong = new Human('小红', 20)
        console.log(xiaoming.__proto__)
        console.log(xiaohong)
 
        //构造函数访问原型是通过prototype
        //实例/变量访问原型是通过__proto__
        //conrtuctor 访问的是一个实例/变量的构造函数
        //__proto__ 访问的是一个实例/变量的原型(一定是一个对象)
 
        function Demo() {
            //{name : edward,age:100}.__proto__ = Demo.prototype
            this.name = 'edward'
            this.age = 100
        }
        Demo.prototype = { aa: 100 }
        console.log(new Demo())
        //new的过程
        //1.执行函数
        //2.在函数中创建一个空对象
        //3.将构造函数的原型作为空对象的原型
        //4.将构造函数中的this指向这个空对象
        //5.return
        //5.1.return基础数据类型
        //5.2.return引用数据类型
 
        // 题目1
        // function foo(something) {
        //     //{a : 3}
        //     this.a = something
        // }
        // var obj1 = {}; //{a : 2}
        // var fn1 = foo.bind(obj1);  //fn1 == foo改变了this
        // fn1(2)
        // var fn2 = new fn1(3);
        // console.log(obj1.a)
        // console.log(fn2.a)
 
        // 1.构造函数
        // 2.bind call apply
        // 3.new的过程
        // 4.this的指向

        //timu2
        function func() {
            this.name = "gridsum"
        }
        console.log(typeof func.prototype);
        func.prototype.getName = function () {
            console.log(this.name)
        }
        const Obj = {};
        Obj.__proto__ = func.prototype;
        func.call(Obj);
        if (Obj.getName) {
            console.log('yes');
            Obj.getName()
        } console.log('end')

//题目3
        function A() { }
        function B(a) {
            this.a = a;
        }
        function C(a) {
            if (a) {
                this.a = a
            }
        }
        A.prototype.a = 1; 
        B.prototype.a = 1; 
        C.prototype.a = 1;
        console.log(new A().a) //1
        console.log(new B().a) //undefined
        console.log(new C().a) //1


    </script>
</body>

</html>